package com.toolconclusion.array;

public class ArraysUtils {
    //    构造方法私有化,保证类不会被创建对象
    private ArraysUtils() {
    }

    // 1、循环打印数组
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }

    // 2、循环打印数组，一行打印指定个数的元素
    public static void print(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
            if ((i + 1) % number == 0) {
                // 换一行
                System.out.println();
            }
        }
    }

    // 3、将数组转成[元素1,元素2...]这种格式的字符串
    public static String formatPrint(int[] arr) {
        if (arr == null)
            return "null";
        // 如果iMax是-1 意味着数组长度是0
        int iMax = arr.length - 1;
        if (iMax == -1)
            return "数组长度为0";
        StringBuilder b = new StringBuilder();
        b.append('[');// 在最前方追加一个[
        for (int i = 0; ; i++) {
            b.append(arr[i]);
            // 满足条件 就退出
            if (i == iMax) {
                return b.append(']').toString();
            }
            b.append(", ");
        }
    }

    // 4、将数组冒泡\或者其他算法排序（直接将原数组排序）
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int desk = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = desk;
                }
            }
        }
    }

    // 5、将数组冒泡\或者其他算法排序（不允许排形参的数组，需要直接返回一个排好序的新数组）
    public static int[] sortNew(int[] arr) {
        int arrNew[] = new int[arr.length];
        // 把源数组 内容赋值一份给 arrNew
        // arrNew = Arrays.copyOf(arr, arr.length);
        for (int i = 0; i < arrNew.length; i++) {
            arrNew[i] = arr[i];
        }

        for (int i = 0; i < arrNew.length - 1; i++) {
            for (int j = 0; j < arrNew.length - 1 - i; j++) {
                if (arrNew[j] > arrNew[j + 1]) {
                    int desk = arrNew[j];
                    arrNew[j] = arrNew[j + 1];
                    arrNew[j + 1] = desk;
                }
            }
        }
        return arrNew;
    }

    // 6、比较两个数组的所有元素是否完全一致
    public static boolean isEquals(int[] arr1, int[] arr2) {
        // 地址相同 里面的数据肯定相同
        if (arr1 == arr2)
            return true;
        if (arr1 == null || arr2 == null)
            return false;

        int length = arr1.length;
        if (arr2.length != length)
            return false;

        for (int i = 0; i < length; i++)
            if (arr1[i] != arr2[i])
                return false;

        return true;
    }

    // 7、计算数组的平均值
    public static double avg(int[] arr) {
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum / arr.length;
    }

    // 8、计算数组的最大值
    public static int max(int[] arr) {
        // 数组第一个 为最大值
        int maxnumber = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (maxnumber < arr[i]) {
                maxnumber = arr[i];
            }
        }
        return maxnumber;
    }

    // 9、计算数组的最小值
    public static int min(int[] arr) {
        // 数组第一个 为最小值
        int minnumber = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (minnumber > arr[i]) {
                minnumber = arr[i];
            }
        }
        return minnumber;
    }

    // 10、将一个数组的所有元素都反转（比如{5,4,8}变成{8,4,5}）
    public static int[] reverse(int[] arr) {
        int[] arrNew = new int[arr.length];
        for (int x = 0; x < arr.length; x++) {
            arrNew[x] = arr[arr.length - 1 - x];
        }
        return arrNew;
    }

    // 11、判断一个指定的数值在数组中是否存在
    public static boolean isExits(int[] arr, int number) {
        boolean isTrue = false;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        // 如果不存在
        return false;
    }
}